home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 290_02 / simple.prs < prev    next >
Text File  |  1990-05-12  |  11KB  |  462 lines
  1. #line 2 "bison.simple"
  2.  
  3. /* Skeleton output parser for bison,
  4.    copyright (C) 1984 Bob Corbett and Richard Stallman
  5.  
  6.  
  7. /* This is the parser code that is written into each bison parser
  8.   when the %semantic_parser declaration is not specified in the grammar.
  9.   It was written by Richard Stallman by simplifying the hairy parser
  10.   used when %semantic_parser is specified.  */
  11.  
  12. /* Note: there must be only one dollar sign in this file.
  13.    It is replaced by the list of actions, each action
  14.    as one case of the switch.  */
  15.  
  16. #define yyerrok        (yyerrstatus = 0)
  17. #define yyclearin    (yychar = YYEMPTY)
  18. #define YYEMPTY        -2
  19. #define YYEOF        0
  20. #define YYFAIL        goto yyerrlab;
  21.  
  22. #define YYTERROR    1
  23.  
  24. #ifndef YYIMPURE
  25. extern int yylex( void) ;
  26. #define YYLEX        yylex()
  27. #endif
  28.  
  29. #ifndef YYPURE
  30. extern int yylex( YYLTYPE *, YYLTYPE *) ;
  31. #define YYLEX        yylex(&yylval, &yylloc)
  32. #endif
  33.  
  34. /* If nonreentrant, generate the variables here */
  35.  
  36. #ifndef YYIMPURE
  37.  
  38. int    yychar;            /*  the lookahead symbol        */
  39. YYSTYPE    yylval;            /*  the semantic value of the        */
  40.                 /*  lookahead symbol            */
  41.  
  42. YYLTYPE yylloc;            /*  location data for the lookahead    */
  43.                 /*  symbol                */
  44.  
  45. int yynerr;            /*  number of parse errors so far       */
  46.  
  47. #ifdef YYDEBUG
  48. int yydebug = 0;        /*  nonzero means print parse trace    */
  49. #endif
  50.  
  51. #endif  /* YYIMPURE */
  52.  
  53.  
  54. /*  YYMAXDEPTH indicates the initial size of the parser's stacks    */
  55.  
  56. #ifndef    YYMAXDEPTH
  57. #define YYMAXDEPTH 200
  58. #endif
  59.  
  60. /*  YYMAXLIMIT is the maximum size the stacks can grow to
  61.     (effective only if the built-in stack extension method is used).  */
  62.  
  63. #ifndef YYMAXLIMIT
  64. #define YYMAXLIMIT 10000
  65. #endif
  66.  
  67.  
  68. #line 167 "bison.simple"
  69. int
  70. yyparse()
  71. {
  72.   register int yystate;
  73.   register int yyn;
  74.   register short *yyssp;
  75.   register YYSTYPE *yyvsp;
  76.   YYLTYPE *yylsp;
  77.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  78.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  79.  
  80.   short    yyssa[YYMAXDEPTH];    /*  the state stack            */
  81.   YYSTYPE yyvsa[YYMAXDEPTH];    /*  the semantic value stack        */
  82.   YYLTYPE yylsa[YYMAXDEPTH];    /*  the location stack            */
  83.  
  84.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  85.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  86.   YYLTYPE *yyls = yylsa;
  87.  
  88.   int yymaxdepth = YYMAXDEPTH;
  89.  
  90. #ifndef YYPURE
  91.   int yychar;
  92.   YYSTYPE yylval;
  93.   YYLTYPE yylloc;
  94. #endif
  95.  
  96. #ifdef YYDEBUG
  97.   extern int yydebug;
  98. #endif
  99.  
  100.  
  101.   YYSTYPE yyval;        /*  the variable used to return        */
  102.                 /*  semantic values from the action    */
  103.                 /*  routines                */
  104.  
  105.   int yylen;
  106.  
  107. #ifdef YYDEBUG
  108.   if (yydebug)
  109.     fprintf(stderr, "Starting parse\n");
  110. #endif
  111.  
  112.   yystate = 0;
  113.   yyerrstatus = 0;
  114.   yynerr = 0;
  115.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  116.  
  117.   /* Initialize stack pointers.
  118.      Waste one element of value and location stack
  119.      so that they stay on the same level as the state stack.  */
  120.  
  121.   yyssp = yyss - 1;
  122.   yyvsp = yyvs;
  123.   yylsp = yyls;
  124.  
  125. /* Push a new state, which is found in  yystate  .  */
  126. /* In all cases, when you get here, the value and location stacks
  127.    have just been pushed. so pushing a state here evens the stacks.  */
  128. yynewstate:
  129.  
  130.   *++yyssp = yystate;
  131.  
  132.   if (yyssp >= yyss + yymaxdepth - 1)
  133.     {
  134.       /* Give user a chance to reallocate the stack */
  135.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  136.       YYSTYPE *yyvs1 = yyvs;
  137.       YYLTYPE *yyls1 = yyls;
  138.       short *yyss1 = yyss;
  139.  
  140.       /* Get the current used size of the three stacks, in elements.  */
  141.       int size = yyssp - yyss + 1;
  142.  
  143. #ifdef yyoverflow
  144.       /* Each stack pointer address is followed by the size of
  145.      the data in use in that stack, in bytes.  */
  146.       yyoverflow("parser stack overflow",
  147.          &yyss1, size * sizeof (*yyssp),
  148.          &yyvs1, size * sizeof (*yyvsp),
  149.          &yyls1, size * sizeof (*yylsp),
  150.          &yymaxdepth);
  151.  
  152.       yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
  153. #else /* no yyoverflow */
  154.       /* Extend the stack our own way.  */
  155.       if (yymaxdepth >= YYMAXLIMIT)
  156.     yyerror("parser stack overflow");
  157.       yymaxdepth *= 2;
  158.       if (yymaxdepth > YYMAXLIMIT)
  159.     yymaxdepth = YYMAXLIMIT;
  160.       yyss = (short *) malloc (yymaxdepth * sizeof (*yyssp));
  161.       memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
  162.       yyvs = (YYSTYPE *) malloc (yymaxdepth * sizeof (*yyvsp));
  163.       memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
  164. #ifdef YYLSP_NEEDED
  165.       yyls = (YYLTYPE *) malloc (yymaxdepth * sizeof (*yylsp));
  166.       memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
  167. #endif
  168. #endif /* no yyoverflow */
  169.  
  170.       yyssp = yyss + size - 1;
  171.       yyvsp = yyvs + size - 1;
  172. #ifdef YYLSP_NEEDED
  173.       yylsp = yyls + size - 1;
  174. #endif
  175.  
  176. #ifdef YYDEBUG
  177.       if (yydebug)
  178.     fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
  179. #endif
  180.  
  181.       if (yyssp >= yyss + yymaxdepth - 1)
  182.     YYABORT;
  183.     }
  184.  
  185. #ifdef YYDEBUG
  186.   if (yydebug)
  187.     fprintf(stderr, "Entering state %d\n", yystate);
  188. #endif
  189.  
  190. /* Do appropriate processing given the current state.  */
  191. /* Read a lookahead token if we need one and don't already have one.  */
  192. yyresume:
  193.  
  194.   /* First try to decide what to do without reference to lookahead token.  */
  195.  
  196.   yyn = yypact[yystate];
  197.   if (yyn == YYFLAG)
  198.     goto yydefault;
  199.  
  200.   /* Not known => get a lookahead token if don't already have one.  */
  201.  
  202.   /* yychar is either YYEMPTY or YYEOF
  203.      or a valid token in external form.  */
  204.  
  205.   if (yychar == YYEMPTY)
  206.     {
  207. #ifdef YYDEBUG
  208.       if (yydebug)
  209.     fprintf(stderr, "Reading a token: ");
  210. #endif
  211.       yychar = YYLEX;
  212.     }
  213.  
  214.   /* Convert token to internal form (in yychar1) for indexing tables with */
  215.  
  216.   if (yychar <= 0)        /* This means end of input. */
  217.     {
  218.       yychar1 = 0;
  219.       yychar = YYEOF;        /* Don't call YYLEX any more */
  220.  
  221. #ifdef YYDEBUG
  222.       if (yydebug)
  223.     fprintf(stderr, "Now at end of input.\n");
  224. #endif
  225.     }
  226.   else
  227.     {
  228.       yychar1 = YYTRANSLATE(yychar);
  229.  
  230. #ifdef YYDEBUG
  231.       if (yydebug)
  232.     fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
  233. #endif
  234.     }
  235.  
  236.   yyn += yychar1;
  237.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  238.     goto yydefault;
  239.  
  240.   yyn = yytable[yyn];
  241.  
  242.   /* yyn is what to do for this token type in this state.
  243.      Negative => reduce, -yyn is rule number.
  244.      Positive => shift, yyn is new state.
  245.        New state is final state => don't bother to shift,
  246.        just return success.
  247.      0, or most negative number => error.  */
  248.  
  249.   if (yyn < 0)
  250.     {
  251.       if (yyn == YYFLAG)
  252.     goto yyerrlab;
  253.       yyn = -yyn;
  254.       goto yyreduce;
  255.     }
  256.   else if (yyn == 0)
  257.     goto yyerrlab;
  258.  
  259.   if (yyn == YYFINAL)
  260.     YYACCEPT;
  261.  
  262.   /* Shift the lookahead token.  */
  263.  
  264. #ifdef YYDEBUG
  265.   if (yydebug)
  266.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  267. #endif
  268.  
  269.   /* Discard the token being shifted unless it is eof.  */
  270.   if (yychar != YYEOF)
  271.     yychar = YYEMPTY;
  272.  
  273.   *++yyvsp = yylval;
  274. #ifdef YYLSP_NEEDED
  275.   *++yylsp = yylloc;
  276. #endif
  277.  
  278.   /* count tokens shifted since error; after three, turn off error status.  */
  279.   if (yyerrstatus) yyerrstatus--;
  280.  
  281.   yystate = yyn;
  282.   goto yynewstate;
  283.  
  284. /* Do the default action for the current state.  */
  285. yydefault:
  286.  
  287.   yyn = yydefact[yystate];
  288.   if (yyn == 0)
  289.     goto yyerrlab;
  290.  
  291. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  292. yyreduce:
  293.   yylen = yyr2[yyn];
  294.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  295.  
  296. #ifdef YYDEBUG
  297.   if (yydebug)
  298.     {
  299.       if (yylen == 1)
  300.     fprintf (stderr, "Reducing 1 value via line %d, ",
  301.          yyrline[yyn]);
  302.       else
  303.     fprintf (stderr, "Reducing %d values via line %d, ",
  304.          yylen, yyrline[yyn]);
  305.     }
  306. #endif
  307.  
  308. $   /* the action file gets copied in in place of this dollarsign */
  309. #line 308 "bison.simple"
  310.  
  311.   yyvsp -= yylen;
  312.   yyssp -= yylen;
  313. #ifdef YYLSP_NEEDED
  314.   yylsp -= yylen;
  315. #endif
  316.  
  317. #ifdef YYDEBUG
  318.   if (yydebug)
  319.     {
  320.       short *ssp1 = yyss - 1;
  321.       fprintf (stderr, "state stack now");